﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HTTT.DataAccess.DataInf;
using HTTT.Utilities;
using System.Data.Objects;

namespace HTTT.DataAccess
{
    public class HT_GroupsDAO : IHT_GroupsDAO
    {
        private static AppEntities dataContext;
        
        private IRepository<HT_Groups> repository;
        public HT_GroupsDAO()
        {
            dataContext = new AppEntities();
            repository = new RepositoryDAO<HT_Groups>(dataContext);
        }

        public IEnumerable<HT_Groups> GetAllHT_Groups()
        {
            var q = (from m in dataContext.HT_Groups
                     select m).Take(500);
            return q;
        }
        public HT_Groups GetHT_GroupsByID(Guid id)
        {
            return repository.Find(obj => obj.ID == id).SingleOrDefault();
        }
        public HT_Groups GetLastRecord()
        {
            return dataContext.HT_Groups.OrderByDescending(obj => obj.ID).FirstOrDefault();
        }

        public bool UpdateHT_Groups(HT_Groups inHT_Groups)
        {
            if (inHT_Groups == null) return false;
            HT_Groups upHT_Groups = repository.First(sobj => sobj.name == inHT_Groups.name);

            if (upHT_Groups == null) return false;

            upHT_Groups.name = inHT_Groups.name;
            upHT_Groups.displayName = inHT_Groups.displayName;
            upHT_Groups.description = inHT_Groups.description;
            upHT_Groups.groupId= inHT_Groups.groupId;
            upHT_Groups.LDAPPath = inHT_Groups.LDAPPath;
            upHT_Groups.groupScope = inHT_Groups.groupScope;
            upHT_Groups.isSecurityGroup = inHT_Groups.isSecurityGroup;
            upHT_Groups.managedBy = inHT_Groups.managedBy;
            upHT_Groups.members = inHT_Groups.members;

            return repository.SaveChanges() > 0;

        }
        public ReturnValue<bool> InsertHT_Groups(HT_Groups inHT_Groups)
        {
            if (inHT_Groups == null) return new ReturnValue<bool>(false, "Input data null");
            repository.Add(inHT_Groups);
            return new ReturnValue<bool>(repository.SaveChanges() > 0, "Input data null");
        }

        public ReturnValue<HT_Groups> InsertHT_GroupsAndReturn(HT_Groups inHT_Groups)
        {
            if (inHT_Groups == null) return new ReturnValue<HT_Groups>(null, "Input value not valid");
            HT_Groups ret = repository.AddAndReturn (inHT_Groups);
            return new ReturnValue<HT_Groups>(ret, "Successfull");
        }

        public ReturnValue<bool> DelHT_Groups(Guid id)
        {
            ReturnValue<bool> ret = new ReturnValue<bool>(false, "");
            try
            {
                HT_Groups objDel = repository.First(obj => obj.ID == id);
                ret = DelHT_Groups(objDel);
            }
            catch (Exception)
            {
                ret.RetValue = false;
                ret.Msg = "Dữ liệu đã được sử dung trong chương trình - không thể xóa !";
            }
            return ret;
        }

        public ReturnValue<bool> DelAllHT_GroupsInPath(string ouPath)
        {
            ReturnValue<bool> ret = new ReturnValue<bool>(false, "");
            try
            {
                
                int result = dataContext.ExecuteStoreCommand("DELETE FROM HT_Groups WHERE LDAPPath LIKE '%"+ouPath+"'");
                return new ReturnValue<bool>(result > 0, "Xóa toàn bộ thành công");
            }
            catch (Exception)
            {
                ret.RetValue = false;
                ret.Msg = "Dữ liệu đã được sử dung trong chương trình - không thể xóa !";
            }
            return ret;
        }


        public ReturnValue<bool> DelHT_Groups(HT_Groups inHT_Groups)
        {
            ReturnValue<bool> ret = new ReturnValue<bool>(false, "");
            if (inHT_Groups == null)
            {
                ret.Msg = "input null";
                return ret;
            }
            try
            {
                repository.Delete(inHT_Groups);
                ret.RetValue = repository.SaveChanges() > 0;
            }
            catch (System.Exception)
            {
                ret.RetValue = false;
                ret.Msg = "Dữ liệu đã được sử dung trong chương trình - không thể xóa !";
            }
            return ret;
        }

        public IEnumerable<HT_Groups> SearchGroups(string keyword, string ouPath)
        {
            try
            {
                if (keyword != string.Empty)
                {
                    var r = from m in dataContext.HT_Groups
                            where m.LDAPPath.Contains(ouPath)
                            && (m.name.Contains(keyword)
                            || m.description.Contains(keyword)
                            || m.displayName.Contains(keyword)
                            )
                            select m;
                    return r;
                }
                else
                {
                    var r = from m in dataContext.HT_Groups
                            where m.LDAPPath.Contains(ouPath)
                            select m;
                    return r;

                }
            }
            catch (Exception)
            {
                return null;
            }
        }

        public HT_Groups GetHT_GroupsByName(string groupName)
        {
            return repository.Find(obj => obj.name == groupName).SingleOrDefault();
        }


        public ReturnValue<bool> DelHT_Groups(string name)
        {
            ReturnValue<bool> ret = new ReturnValue<bool>(false, "");
            try
            {
                HT_Groups objDel = repository.First(obj => obj.name == name);
                ret = DelHT_Groups(objDel);
            }
            catch (Exception)
            {
                ret.RetValue = false;
                ret.Msg = "Dữ liệu đã được sử dung trong chương trình - không thể xóa !";
            }
            return ret;
        }

        public bool IsInOU(string path)
        {
            return repository.Exist(m => m.LDAPPath.Contains(path));
        }
    }
}
